package GenericStudy.Exa3;

/**
 * 实现泛型排序
 */
public class GenericComparison {

    /**
     * 获得泛型数组array中最小的元素(元素必须实现了Compareable接口)
     * 其中的<T extends Comparable>这个用法表示此泛型方法只接受Comparable的子类型作为泛型，从而限制泛型的范围。
     * 例如我们使用了没有实现Comparable的类型使用此泛型方法时，在编译期就会报错
     * @param array 泛型数组
     * @param <T> 类型变量
     * @return 元素
     */
    public static <T extends Comparable<T>> T getMin(T[] array) {
        if (array == null || array.length == 0) {
            return null;
        }
        T min = array[0];
        
        for (int i = 1; i < array.length; i++) {
            if (min.compareTo(array[i]) > 0) {
                min = array[i];
            }
        }
        return min;
    }

    /**
     * 泛型方法，计算数组array中的最大值
     * @param array
     * @param <T>
     * @return
     */
    public <T extends Comparable<T>> T getMax(T[] array) {
        if (array == null || array.length == 0) {
            return null;
        }
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }

    /**
     * 泛型排序方法，冒泡排序实现
     * @param array
     * @param <T>
     * @return
     */
    public static <T extends Comparable<T>> T[] sorted(T[] array){
        if (array == null || array.length == 0) {
            return null;
        }
        for (int i = 0; i < array.length; i++) {
            for(int j=0;j<array.length;j++){
                if(array[i].compareTo(array[j])<0){
                    T temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }

}
